<!--
  费率配置：

  @author terrfly
  @site https://www.jeequan.com
  @date 2022/04/06 10:14
-->

<!--

   费率配置面板，  支持9种模式： 

  ( mgrIsv ) 运营平台对服务商的配置：  查询【服务商所有支持的支付方式】
  支付产品 、 [配置]服务商底价、  [配置]代理商默认费率、  [配置]商户默认费率。 

  ( mgrAgent ) 运营平台对代理商的费率配置： 查询： 【代理的所属服务商 、 所属上级代理商的所有开通的支付产品】 
  支付产品、 [显示]服务商底价， [显示]上级代理商费率、  [配置]代理商的费率、  [配置]下级代理商的默认费率、  [配置]商户默认费率。 

  ( mgrMch ) 运营平台对商户：  查询【商户的所属服务商 、 所属上级代理商的所有开通的支付产品】
  支付产品、 [显示]服务商底价， [显示]上级代理商费率、  [配置]商户的费率。 

  ( agentSelf ) 代理商 对自己：   查询【当前代理商已经开通的产品】
  支付产品、 [显示]当前代理商的费率、  [配置]下级代理商的默认费率、  [配置]商户默认费率。

  ( agentSubagent ) 代理商对下级代理商：  查询【当前代理商已经开通的产品】
  支付产品、 [显示]当前代理商的费率、  [配置]下级代理商的费率

  ( agentMch ) 代理商对商户： 查询【当前代理商已经开通的产品】
  支付产品、 [显示]上级代理商费率、  [配置]商户的费率。 


  ( mgrApplyment ) 显示方式同： mgrMch。  只是不需要 切换支付接口和保存按钮    新增按钮： 查询默认费率。 

  ( agentApplyment ) 显示方式同： agentMch  只是不需要 切换支付接口和保存按钮.   新增按钮： 查询默认费率。 

  ( mchApplyment ) 不需要 切换支付接口和保存按钮.   显示的就是代理商或者服务商配置的默认费率。 
  -->

<template>
  <div>
    <!--旧版 -->
    <JeepayPaywayRatePanelOldPage
      v-if="vdata.isSwitchOldPage"
      :infoId="props.infoId" 
      :configMode="props.configMode" 
      :selectIfCode="props.selectIfCode" 
      :onlyRate="props.onlyRate" 
      :showSaveBtn="props.showSaveBtn" 
    />

    <!-- 新版  && 显示 保存按钮的才需要切换旧版。 -->
    <div v-if="!vdata.isSwitchOldPage" class="drawer">
      <a-alert v-if="isAllowShowSwitchOldBtn()" type="info">
        <template #message>
          <a-button type="link" @click="vdata.isSwitchOldPage= true">切换到旧版</a-button>
        </template>
      </a-alert>

      <!-- 费率配置 面板   仅选择了支付接口才可见 -->
      <div v-if="vdata.currentIfCode" style="margin-bottom: 15px;">
        <!-- 遍历所有的支付产品类型 -->
        <template v-for="(item, i) in vdata.mergeFeeList" :key="i">
          <JeepayPaywayRatePanelInnerPaywayTypeCard :mergeFeeByProps="item" :configMode="props.configMode" />
        </template>
      </div>
    
      <!-- 只有运营平台配置的商户， 才可以配置 商户0费率  -->
      <a-collapse v-if="props.configMode == 'mgrMch'">
        <a-collapse-panel key="a1" header="【保存】高级配置项">
          <a-checkbox v-model:checked="vdata.noCheckRuleFlag">本商户为特殊商户， 不校验上下级的费率比较规则， 允许低于服务商的底价。 </a-checkbox>
        </a-collapse-panel>
      </a-collapse>
    
      <!-- 只有运营平台配置的 服务商， 才可以 忽略项目  -->
      <a-collapse v-if="props.configMode == 'mgrIsv'">
        <a-collapse-panel key="a2" header="【保存】高级配置项">
          <a-checkbox v-model:checked="vdata.noCheckRuleFlag">不校验服务商的费率配置信息 （仅特殊情况才可使用）。 </a-checkbox>
        </a-collapse-panel>
      </a-collapse>
    
      <div v-if="!props.onlyRate && showSaveBtn" :class=" props.configMode == 'agentSelf' ? 'drawer-btn-center-payfee' : 'drawer-btn-center'">
        <a-button type="primary" @click="onSubmit"><check-outlined />保存</a-button>
      </div>
    </div>
  </div>
</template>
    
  <script lang="ts" setup >
  import { $getRateConfigPayways, $getRateConfigSavedMapData, $saveRateConfig } from '@/api/manage'
  import { reactive, getCurrentInstance, onMounted, defineExpose, provide, computed } from 'vue'
  
  // 导入全局函数
  const { $infoBox, $hasAgentEnt } = getCurrentInstance()!.appContext.config.globalProperties
  
  // 定义父组件的传值
  const props : any = defineProps({
  
    infoId: { type: String, default: '' }, // 当前配置的所属infoId
    configMode: { type: String, default: '' },   // 模式
    selectIfCode: { type: String ,default: '' }, // 默认选中的支付接口
    onlyRate: { type: Boolean ,default: false }, // 是否只有费率的模式， true: 只显示费率（一般进件模式选择该方式, 并且配合selectIfCode使用），  false 显示支付接口和保存按钮。 
    showSaveBtn: { type: Boolean ,default: true }, // 是否显示保存按钮， 当向三方申请保存费率申请时，不需要显示。 
  
  })
  
  // 判断是否可显示  切换旧版 
  function isAllowShowSwitchOldBtn(){

    // 不是只读模式  && 需要显示保存按钮 && 运营平台配置项目才可以 
    return (!props.onlyRate && props.showSaveBtn && ( props.configMode == 'mgrIsv' || props.configMode == 'mgrAgent' || props.configMode == 'mgrMch' || props.configMode == 'mgrApplyment'  ) )
  }

  
  // 定义响应式数据
  const vdata : any = reactive({

        isSwitchOldPage: false,  // 是否显示旧版。 

        currentIfCode : '', //当前选择的支付通道
        btnLoading: false, // 按钮loading 
        jeepayPaywayFeeFlag: false, // 是否显示费率组件（用于重新渲染组件）
  
        showSetFeeModal: false, //显示统一设置 弹层
        showSetFeeModalMode: '', //设置类型
        showSetFeeModalValue: 0, //设置的费率
        showSetIsOpenValue: true, //设置统一的开关
        
        allPaywayList : [], //费率设置的集合 
        allPaywayMap : {}, // 费率设置的集合 Map
  
        //  key  = ifCode 
        // mainRateMap 表示多个费率值的设置：   ISVCOST,  AGENT,  MCH,  根据传入的不同进行不同结果的返回。 
        mainRateMap: {},
  
        agentdefMap: {}, // 代理商默认费率
        mchapplydefMap: {}, // 商户进件默认费率
  
        savedMapDataHasReadonlyIsvCostRateMap : false, // 原始返回数据是否 包含服务商费率 
        readonlyIsvCostRateMap: {}, // 服务商底价（用于显示）
        readonlyParentAgentRateMap: {}, // 上级代理商费率（用于显示）
        readonlyParentDefRateRateMap: {}, // 商户的上级的默认费率（用于读取并赋值到input）
  
        noCheckRuleFlag: false, // 特殊商户， 不进行验证费率规则

        originSavedList: [], // 原始数据（打开页面查询的 修改配置前的 数据集合。 ）


        // 合并模式的 配置项： 类型、 支持的支付产品列表、 配置信息、 是否合并模式
        // key : 分类key
        // name: 回显的名称
        // mainFee: 合并模式下， 修改的 【主要】 费率值
        // agentdefFee: 合并模式下， 修改的 【下级代理商默认】 费率值
        // mchapplydefFee: 合并模式下， 修改的 【下级商户进件默认】 费率值
        // isMergeMode: 标识 是否合并模式 
        // selectedWayCodeList :  勾选的产品(彻底与拆分的数据进行了分割), 在进入页面后就进行了查询并且设置了非勾选状态： 格式：  { wayCode: '', wayName:'', checked: true }
        // filter: 该分类下包含哪些产品的过滤器
        mergeFeeList: [
          {
            key: 'WECHAT1', name: '微信线下', mainFee: {}, agentdefFee: {}, mchapplydefFee: {}, isMergeMode: false,
            selectedWayCodeList:[],
            filter: (r) => { return (r.wayType == 'WECHAT' && ['WX_BAR','WX_JSAPI','WX_LITE'].indexOf(r.wayCode) >= 0 ) }
          },
          {
            key: 'WECHAT2', name: '微信线上',  mainFee: {}, agentdefFee: {}, mchapplydefFee: {}, isMergeMode: false,
            selectedWayCodeList:[], 
            filter: (r) => { return (r.wayType == 'WECHAT' && ['WX_BAR','WX_JSAPI','WX_LITE'].indexOf(r.wayCode) < 0 ) },  
          },
          {
            key: 'ALIPAY1', name: '支付宝线下',  mainFee: {}, agentdefFee: {}, mchapplydefFee: {}, isMergeMode: false,
            selectedWayCodeList:[], 
            filter: (r) => { return  (r.wayType == 'ALIPAY' && ['ALI_BAR', 'ALI_JSAPI', 'ALI_LITE', 'ALI_QR'].indexOf(r.wayCode) >= 0 ) }
          },
          {
            key: 'ALIPAY2', name: '支付宝线上',  mainFee: {}, agentdefFee: {}, mchapplydefFee: {}, isMergeMode: false,
            selectedWayCodeList:[], 
            filter: (r) => { return (r.wayType == 'ALIPAY' && ['ALI_BAR', 'ALI_JSAPI', 'ALI_LITE', 'ALI_QR'].indexOf(r.wayCode) < 0) }
          },
          {
            key: 'YSFPAY', name: '云闪付',  mainFee: {}, agentdefFee: {}, mchapplydefFee: {}, isMergeMode: false,
            selectedWayCodeList:[], 
            filter: (r) => { return r.wayType == 'YSFPAY' }
          },
          {
            key: 'UNIONPAY', name: '银联',  mainFee: {}, agentdefFee: {}, mchapplydefFee: {}, isMergeMode: false,
            selectedWayCodeList:[], 
            filter: (r) => { return r.wayType == 'UNIONPAY' }
          },
          {
            key: 'DCEPPAY', name: '数字人民币',  mainFee: {}, agentdefFee: {}, mchapplydefFee: {}, isMergeMode: false,
            selectedWayCodeList:[], 
            filter: (r) => { return r.wayType == 'DCEPPAY' }
          },
          {
            key: 'OTHER', name: '其他', mainFee: {}, agentdefFee: {}, mchapplydefFee: {}, isMergeMode: false,
            selectedWayCodeList:[], 
            filter: (r) => { return r.wayType == 'OTHER' }
          },
          {
            key: 'TRANSFER', name: '转账', mainFee: {}, agentdefFee: {}, mchapplydefFee: {}, isMergeMode: false,
            selectedWayCodeList:[], 
            filter: (r) => { return r.wayType == 'TRANSFER' }
          },
        ]
  })
  
  // 挂载钩子函数 
  onMounted(() => {
    
    vdata.currentIfCode = '' // 默认不选中
  
    vdata.currentIfCode = props.selectIfCode // 默认接口
  
    // 重新渲染配置面板
    if(vdata.currentIfCode){
      reloadRatePanel(null) 
    }
  
  })


  // 生成 默认费率数据 
  function genFeeDefObject(wayCode, isTransferIfProduct){

    const defObject : any = {
      wayCode: wayCode, // 需要覆写
      state: 0, // 默认不开通
      applymentSupport: 0, // 进件是否显示
      feeType: isTransferIfProduct ? 'TRANSMODE': 'SINGLE', // 默认单笔费率,  转账类型特殊标识为：  TRANSMODE （费率项目）
      levelList: [], // 阶梯费率数组 
    }

    // 转账类型需要: 默认值
    if(isTransferIfProduct){
      defObject.fixFee = 0
      defObject.minFee = 0
      defObject.maxFee = 99999
    }

    return JSON.parse(JSON.stringify(defObject))

  }
  
  
  // 重置 【费率配置】面板
  async function reloadRatePanel(reloadRateData){
  
    // 数据的重置
    vdata.allPaywayList = [] 
    vdata.allPaywayMap = {}
  
    vdata.mainRateMap = {} // 主要配置信息 
    vdata.agentdefMap = {} // 代理商默认 费率 
    vdata.mchapplydefMap = {} // 商户进件 默认费率 
    vdata.readonlyIsvCostRateMap = {}  // 【只读】 服务商底价 
    vdata.readonlyParentAgentRateMap = {} // 【只读】 上级代理商配置费率
    vdata.readonlyParentDefRateRateMap = {} // 【只读】 上级设置的该角色默认费率

    vdata.originSavedList = [] // 清空信息 

    // 清空 合并选择信息
    vdata.mergeFeeList.forEach(elementItem => {
      elementItem.mainFee = {}
      elementItem.agentdefFee = {}
      elementItem.mchapplydefFee = {}
      elementItem.isMergeMode = false
      elementItem.selectedWayCodeList = []
    })
  
    // 当前保存的数据 (DB中的)
    let savedMap : any = {}

    //查询当前已经配置的费率 
    await $getRateConfigSavedMapData(props.infoId, props.configMode, vdata.currentIfCode).then((savedMapRes) => {
      savedMap = savedMapRes

      // 包含重新加载的数据
      if(reloadRateData){
        savedMap.ISVCOST = reloadRateData.ISVCOST
        savedMap.AGENTRATE = reloadRateData.AGENTRATE
        savedMap.MCHRATE = reloadRateData.MCHRATE
        savedMap.AGENTDEF = reloadRateData.AGENTDEF
        savedMap.MCHAPPLYDEF = reloadRateData.MCHAPPLYDEF
      }

    })
  
    // 查询全部支付产品列表 
    await $getRateConfigPayways(props.infoId, props.configMode, vdata.currentIfCode).then((res) => {

  
        res.records.forEach(item => {

            item.checked = false // 批量选择， 默认不选中
            vdata.allPaywayList.push(item)
            vdata.allPaywayMap[item.wayCode] = item

            // 初始化数据 
            vdata.mainRateMap[item.wayCode] = genFeeDefObject(item.wayCode, checkIsTransferIfProduct(item))
            vdata.agentdefMap[item.wayCode] = genFeeDefObject(item.wayCode, checkIsTransferIfProduct(item))
            vdata.mchapplydefMap[item.wayCode] = genFeeDefObject(item.wayCode, checkIsTransferIfProduct(item))
  
            vdata.readonlyIsvCostRateMap[item.wayCode] = genFeeDefObject(item.wayCode, checkIsTransferIfProduct(item))
            vdata.readonlyParentAgentRateMap[item.wayCode] = genFeeDefObject(item.wayCode, checkIsTransferIfProduct(item))
            vdata.readonlyParentDefRateRateMap[item.wayCode] = genFeeDefObject(item.wayCode, checkIsTransferIfProduct(item))


            // 初始化： 合并模式下的  初始化数据 
            vdata.mergeFeeList.forEach(me => {
              me.mainFee = genFeeDefObject(null, me.key == 'TRANSFER')
              me.agentdefFee = genFeeDefObject(null, me.key == 'TRANSFER')
              me.mchapplydefFee = genFeeDefObject(null, me.key == 'TRANSFER')
            })
            
        })

        // 处理 合并模式的 可勾选的支付产品
        vdata.mergeFeeList.forEach( r => {
          vdata.allPaywayList.filter(r.filter).forEach( r1 => {
            r.selectedWayCodeList.push({ wayCode: r1.wayCode, wayName: r1.wayName, checked: false })
          })
        })

  
        // 服务商底价
        if(savedMap && savedMap.ISVCOST){
          changeList('mainRateMap', savedMap.ISVCOST)
          vdata.originSavedList = JSON.parse(JSON.stringify(Object.keys(savedMap.ISVCOST)))
        }
  
        // 代理商费率
        if(savedMap && savedMap.AGENTRATE){
          vdata.originSavedList = JSON.parse(JSON.stringify(Object.keys(savedMap.AGENTRATE)))
          changeList('mainRateMap', savedMap.AGENTRATE)
        }
  
        // 商户费率 （此上三个 后台返回接口  三选一 ）
        if(savedMap && savedMap.MCHRATE){
          changeList('mainRateMap', savedMap.MCHRATE)
        }
  
  
        // 代理商默认费率
        if(savedMap && savedMap.AGENTDEF){
          changeList('agentdefMap', savedMap.AGENTDEF)
        }
  
        // 商户默认费率
        if(savedMap && savedMap.MCHAPPLYDEF){
          changeList('mchapplydefMap', savedMap.MCHAPPLYDEF)
        }
  
  
        // 服务商底价（用于显示）
        if(savedMap && savedMap.READONLYISVCOST){
          vdata.savedMapDataHasReadonlyIsvCostRateMap = true 
          changeList('readonlyIsvCostRateMap', savedMap.READONLYISVCOST)
        }
  
  
        // 上级代理商费率（用于显示）
        if(savedMap && savedMap.READONLYPARENTAGENT){
          changeList('readonlyParentAgentRateMap', savedMap.READONLYPARENTAGENT)
        }
  
        // 上级配置的默认费率（用于显示）
        if(savedMap && savedMap.READONLYPARENTDEFRATE){
          changeList('readonlyParentDefRateRateMap', savedMap.READONLYPARENTDEFRATE)
        }

    // http 查询全部支付产品列表  结束
    })


    // 返回 false:  明确 拆分模式
    // 返回  Object 并且不是 null, 合并模式 并且包含了合并的数据
    // 返回 null :  可合并可拆分，  未设置任何数据 （list length = 0 ）。 

    // agentdefOrmchapplydef = 代理商or商户默认进件默认费率的配置下项：需特殊判断。 
    function checkIsMergeMode(array, agentdefOrmchapplydef = false){

      // notsetIgnore : 代理商默认和商户进件默认支持不配置， 所需不可以忽略。  原有逻辑是直接忽略（true）
      let notsetIgnore = true

      let mergeStr : any = null

      for (let index = 0; index < array.length; index++) {

        let obj = JSON.parse(JSON.stringify(array[index]))

        // 代理商or商户默认进件默认费率 需要判断主状态：   
        // 例如：  A、 微信条码 (WX_BAR)   整条关闭；   微信小程序 (WX_LITE)   配置： 底价1， 代理商默认空， 进件默认为 1， 此时显示不正确。 
        // 例如：  B、 微信条码 (WX_BAR)  微信小程序 (WX_LITE)   服务商底价费率一样、 代理商一样， 进件默认不同， 显示不正确。 
        // A 和 B 仅有当前时判断不出来， 所以需要判断主条目的状态。 
        if(agentdefOrmchapplydef){

          notsetIgnore = false  // 判断state 

          // 但是当主条目关闭时：  整条关闭， 那么此时需要为 true 
          if( !vdata.mainRateMap[obj.wayCode] || vdata.mainRateMap[obj.wayCode].state != 1){
            notsetIgnore = true
          }

        }

        // DB查询出的状态 为 0， 表明未配置， 直接忽略此行。 
        if(notsetIgnore && obj.state != 1){
          continue
        }

        obj.wayCode = null // 忽略wayCode

        // 第一次，没有任何记录 
        if(mergeStr == null){
          mergeStr = JSON.stringify(obj)
          continue
        }

        // 相同
        if(JSON.stringify(obj) == mergeStr){
          continue

        }else{ // 不同， 直接函数返回 false 

          console.log('判断为false: ', JSON.stringify(obj), mergeStr)

          return false
        }
        
      }

      return mergeStr == null ? null : JSON.parse(mergeStr)
    }


    // 判断是否合并模式
    // 1. 查询出所有的分类
    vdata.mergeFeeList.forEach(me => {

      // 默认 不合并 
      me.isMergeMode = false

      // 2. 查询出所有的支付产品（该分类下的）
      const allPaywayCodeList : any = []
      me.selectedWayCodeList.forEach(payway => allPaywayCodeList.push(payway.wayCode))

      // 3. 判断主要的赋值支付完全相同
      let mainFeeMergeMode = checkIsMergeMode(Object.values(vdata.mainRateMap).filter((r : any ) => { return allPaywayCodeList.indexOf(r.wayCode) >= 0 }))

      let agentdefFeeMergeMode = checkIsMergeMode(Object.values(vdata.agentdefMap).filter((r : any ) => { return allPaywayCodeList.indexOf(r.wayCode) >= 0 }), true)

      let mchapplydefFeeMergeMode = checkIsMergeMode(Object.values(vdata.mchapplydefMap).filter((r : any ) => { return allPaywayCodeList.indexOf(r.wayCode) >= 0 }), true)

      // 服务商底价是否合并模式  ( readonly也需要判断， 比如：  服务商配置的信息不同，但是代理商是合并配置的。  此时也应该拆分。  )
      let readonlyIsvCostRateMergeMode = checkIsMergeMode(Object.values(vdata.readonlyIsvCostRateMap).filter((r : any ) => { return allPaywayCodeList.indexOf(r.wayCode) >= 0 }))

       // 【只读】 上级代理商配置费率
      let readonlyParentAgentRateMergeMode = checkIsMergeMode(Object.values(vdata.readonlyParentAgentRateMap).filter((r : any ) => { return allPaywayCodeList.indexOf(r.wayCode) >= 0 }))


      console.log('判断合并模式： ', me.key, mainFeeMergeMode, agentdefFeeMergeMode, mchapplydefFeeMergeMode, readonlyIsvCostRateMergeMode, readonlyParentAgentRateMergeMode)

      // 可以合并 (  null or Object )
      if(typeof(mainFeeMergeMode) == 'object' && typeof(agentdefFeeMergeMode) == 'object' && typeof(mchapplydefFeeMergeMode) == 'object'
      && typeof(readonlyIsvCostRateMergeMode) == 'object' && typeof(readonlyParentAgentRateMergeMode) == 'object'
      ){

        if(mainFeeMergeMode) me.mainFee = mainFeeMergeMode
        if(agentdefFeeMergeMode) me.agentdefFee = agentdefFeeMergeMode
        if(mchapplydefFeeMergeMode) me.mchapplydefFee = mchapplydefFeeMergeMode

        // 是否勾选
        me.selectedWayCodeList.forEach(sw => {
          sw.checked = (vdata.mainRateMap[sw.wayCode] != null && vdata.mainRateMap[sw.wayCode].state == 1)

          // 如果查询到没有任何配置（第一次配置）， 那么默认勾选
          if(sw.checked == false 
          && (props.configMode == 'mgrAgent' || props.configMode == 'mgrMch'|| props.configMode == 'mgrApplyment' )
          && (!vdata.mainRateMap || Object.keys(vdata.mainRateMap).filter( rk => vdata.mainRateMap[rk].state == 1).length == 0)){

            sw.checked = true
          }

        })

        // 明确合并模式
        me.isMergeMode = true

      }


    })
    // 判断是否合并 结束
  }
  
  
  // 保存按钮 
  function onSubmit(){
  
    let reqPaywayFeeList = getReqPaywayFeeList()
    if(!reqPaywayFeeList){ // 报错
        return false 
    }


    let checkDelArrayFunc = (list) =>{
      let result : any = []
      vdata.originSavedList.forEach(originWayCode => {
        if(list.filter( r => r.wayCode == originWayCode).length <= 0){
          result.push(originWayCode)
        }
      })
      return result
    }


    // 删除的支付产品集合
    let delPaywayCode = []

    // 重置的原始list 
    let resetOriginSavedList :any  = null

    if(props.configMode == 'mgrIsv'){
      delPaywayCode = checkDelArrayFunc(reqPaywayFeeList.ISVCOST)

      resetOriginSavedList = []
      reqPaywayFeeList.ISVCOST.forEach(element => {
        resetOriginSavedList.push(element.wayCode)
      })
  
    }else if(props.configMode == 'mgrAgent' || props.configMode == 'agentSubagent'){
      delPaywayCode = checkDelArrayFunc(reqPaywayFeeList.AGENTRATE)

      resetOriginSavedList = []
      reqPaywayFeeList.AGENTRATE.forEach(element => {
        resetOriginSavedList.push(element.wayCode)
      })
    }

    let content = ''
    if(delPaywayCode.length > 0){
      content = '系统检测到关闭了' + delPaywayCode.length + '个支付产品：【'
      delPaywayCode.forEach( r=> {

        // 包含该产品。 
        if(vdata.allPaywayMap[r]){
          content += `${vdata.allPaywayMap[r].wayName}(${r});`

        }else{ // 已关闭的：  比如： 接口关闭了该支付方式， 此时配置仍然有， 但是无法正常回显。 
          content += `${r}(已禁用);`
        }
        
      })
      content += '】， 点击确定将同时关闭操作对象的下级代理商和商户的配置！'
    }


    $infoBox.confirmDangerPromise('确认操作?', content).then(resInfo => {

      // 请求对象
      let reqObject = {infoId: props.infoId, ifCode: vdata.currentIfCode, configMode: props.configMode, noCheckRuleFlag: vdata.noCheckRuleFlag ? 1: 0, delPaywayCodeListStr: JSON.stringify(delPaywayCode) }
      Object.assign(reqObject, reqPaywayFeeList) // 合并对象
    
      $saveRateConfig(reqObject).then((res) => {
        $infoBox.message.success('保存成功')

        if(typeof resetOriginSavedList == 'object'){
          console.log('重置的原始list', resetOriginSavedList)
          vdata.originSavedList = resetOriginSavedList
        }

      })
    })
   
  }
  
  
  // 更改当前可视化的值 （此时已经查询到了全部支付方式了）
  // savedMap : 当前DB保存的数据
  function changeList(mode, savedMap){
  
    // 全部支付方式
    let valList : any = Object.values(vdata[mode])
  
    valList.forEach(element => {
      
  
      // 数据初始化操作
      element.feeType = checkIsTransferIfProduct(element) ? 'TRANSMODE' : 'SINGLE'

      delete element.feeRate
      delete element.minFee
      delete element.maxFee
      element.levelList = []
  
      let record = savedMap[element.wayCode] || {}
  
      //复制到数组中 
      Object.assign(element, record)
      element.checked = false
  
      element.state = savedMap[element.wayCode] ? 1 : 0 //默认开通
  
      // 明确关闭
      if(savedMap[element.wayCode] && savedMap[element.wayCode].state === 0){
          element.state = 0
      }
      
      // 转换费率和金额格式
  
      if(typeof(element.feeRate) == 'number'){
          element.feeRate = Number.parseFloat((element.feeRate * 100).toFixed(6))
      }
  
      if(typeof(element.maxFee) == 'number'){
          element.maxFee = Number.parseFloat((element.maxFee / 100).toFixed(2))
      }
  
      if(typeof(element.minFee) == 'number'){
          element.minFee = Number.parseFloat((element.minFee / 100).toFixed(2))
      }

      if(typeof(element.fixFee) == 'number'){ // 转账模式需要
          element.fixFee = Number.parseFloat((element.fixFee / 100).toFixed(2))
      }
  
      if(element.levelList){
          element.levelList.forEach(levelItem => {
              if(typeof(levelItem.feeRate) == 'number'){
                  levelItem.feeRate = Number.parseFloat((levelItem.feeRate * 100).toFixed(6))
              }
  
              if(typeof(levelItem.maxFee) == 'number'){
                  levelItem.maxFee = Number.parseFloat((levelItem.maxFee / 100).toFixed(2))
              }
  
              if(typeof(levelItem.minFee) == 'number'){
                  levelItem.minFee = Number.parseFloat((levelItem.minFee / 100).toFixed(2))
              }
          })
      }
  
      // 贷记卡的金额回显
      if(element.creditCardPaywayFee){
        
        if(typeof(element.creditCardPaywayFee.feeRate) == 'number'){
            element.creditCardPaywayFee.feeRate = Number.parseFloat((element.creditCardPaywayFee.feeRate * 100).toFixed(6))
        }
  
        if(typeof(element.creditCardPaywayFee.maxFee) == 'number'){
            element.creditCardPaywayFee.maxFee = Number.parseFloat((element.creditCardPaywayFee.maxFee / 100).toFixed(2))
        }
  
        if(typeof(element.creditCardPaywayFee.minFee) == 'number'){
            element.creditCardPaywayFee.minFee = Number.parseFloat((element.creditCardPaywayFee.minFee / 100).toFixed(2))
        }
  
        if(element.creditCardPaywayFee.levelList){
            element.creditCardPaywayFee.levelList.forEach(levelItem => {
                if(typeof(levelItem.feeRate) == 'number'){
                    levelItem.feeRate = Number.parseFloat((levelItem.feeRate * 100).toFixed(6))
                }
  
                if(typeof(levelItem.maxFee) == 'number'){
                    levelItem.maxFee = Number.parseFloat((levelItem.maxFee / 100).toFixed(2))
                }
  
                if(typeof(levelItem.minFee) == 'number'){
                    levelItem.minFee = Number.parseFloat((levelItem.minFee / 100).toFixed(2))
                }
            })
        }
      }
  
        
    })
  }
  
  // 获取请求数据的对象格式 (包含了验证规则)
  // 返回格式： { ISVCOST: []   AGENTDEF:[]   MCHAPPLYDEF:[] }
  function getReqPaywayFeeList(){

   for (let mi = 0; mi < vdata.mergeFeeList.length; mi++) {
      const miElement =  vdata.mergeFeeList[mi]

      // 合并模式 && 包含产品 && 全部未勾选 && 开通开关为true 
      if(miElement.isMergeMode && miElement.selectedWayCodeList.length > 0 && miElement.selectedWayCodeList.filter( r=> r.checked).length <= 0 && miElement.mainFee.state == 1){
        $infoBox.message.error(`【${miElement.name}】合并模式为开通状态但没有选择任何产品， 请点击关闭或勾选产品！`)
        return false
      }
    }
  
    let mainRateList = getReqPaywayFeeListByList('mainFee', Object.values(vdata.mainRateMap))
  
    if(typeof(mainRateList) != 'object'){
        return false
    }
  
    let agentdefList = null
    let mchapplydefList = null

    // 部分业务需要该判断， 其他的不需要校验 和 获取 
    if(props.configMode == 'mgrIsv' || props.configMode == 'mgrAgent' || props.configMode == 'agentSelf' ){
      if ($hasAgentEnt()) {
        agentdefList = getReqPaywayFeeListByList('agentdefFee', Object.values(vdata.agentdefMap))
        if(typeof(agentdefList) != 'object'){
            return false
        }
      }
    
      mchapplydefList = getReqPaywayFeeListByList('mchapplydefFee', Object.values(vdata.mchapplydefMap), true)
      if(typeof(mchapplydefList) != 'object'){
          return false
      }
    }
  
    if(props.configMode == 'mgrIsv'){
        return { ISVCOST: mainRateList, AGENTDEF: agentdefList, MCHAPPLYDEF: mchapplydefList  }
  
    }else if(props.configMode == 'mgrAgent'){
        return { AGENTRATE: mainRateList, AGENTDEF: agentdefList, MCHAPPLYDEF: mchapplydefList  }
  
    }else if(props.configMode == 'mgrMch' || props.configMode == 'agentMch' || props.configMode == 'mgrApplyment' || props.configMode == 'mchApplyment' || props.configMode == 'agentApplyment' ){
        return { MCHRATE: mainRateList }
        
    }else if(props.configMode == 'agentSubagent'){
        return { AGENTRATE: mainRateList }
        
    }else if(props.configMode == 'agentSelf'){
        return { AGENTDEF: agentdefList, MCHAPPLYDEF: mchapplydefList  }
  
    }else if(props.configMode == 'mchSelfApp1'){ // 普通商户的设置
        return { MCHRATE: mainRateList }
    }
  
  
  }
  
  // element(原始数据) -->  obj（新对象的数据）
  // 当前一切正常，返回 true
  function levelFeeElementConvertObj(obj, element, ifNotsetContinue){

      let resFunc = (msg) => {
        if(ifNotsetContinue){ // 自动跳过， 直接返回false, 不提示出来。 
          return false  
        }
        $infoBox.message.error(msg)
        return false
      }
  
      if(typeof(element.minFee) != 'number'){
        return resFunc('阶梯费率请填入保底费用')
      }
      if(typeof(element.maxFee) != 'number'){
        return resFunc('阶梯费率请填入封顶费用')
      }
  
      obj.minFee = Number.parseInt(element.minFee * 100 + '')
      obj.maxFee = Number.parseInt(element.maxFee * 100 + '')
  
  
      let levelList :any = []
      for (let y = 0; y < element.levelList.length; y++) {
          let levelItem =  element.levelList[y]
  
          let levelCopy :any = {}
  
          if(typeof(levelItem.feeRate) != 'number' || levelItem.feeRate <= 0){
              return resFunc('请录入阶梯费率')
          }
  
          if(typeof(levelItem.minFee) != 'number'){
              return resFunc('阶梯费率请填入金额区间值')
          }
          if(typeof(levelItem.maxFee) != 'number'){
              return resFunc('阶梯费率请填入金额区间值')
          }
  
          levelCopy.feeRate = Number.parseFloat((levelItem.feeRate / 100).toFixed(6))
          levelCopy.minFee = Number.parseInt(levelItem.minFee * 100 + '')
          levelCopy.maxFee = Number.parseInt(levelItem.maxFee * 100 + '')
          levelList.push(levelCopy)
      }
  
      obj.levelList = levelList
      if(obj.levelList.length <= 0 ){
          return resFunc('阶梯费率请至少包含一个价格区间')
      }
  
      return true
  }


// 根据 wayCode 查询出合并模式的信息
// return Object : 合并模式, 并且勾选了： 返回 [合并配置, checked] 是否选中。 
// return [null, false] :无合并信息   
function getMergeFeeObjectByWaycode(wayCode){

  for(let index = 0; index < vdata.mergeFeeList.length; index++) {
    const element = vdata.mergeFeeList[index]
    for (let index2 = 0; index2 < element.selectedWayCodeList.length; index2++) {
      const wayCodeObj = element.selectedWayCodeList[index2]
      if(wayCodeObj.wayCode == wayCode){
        return [element, wayCodeObj.checked]
      }
    }
  }

  return [null, false]
}


// 通用获取费率配置信息
function getReqPaywayFeeListByList(mergeFeeProps, list, filterApplymentSupport = false) {

  // 当设置为空时， 是否自动跳过该参数， 一般用作： 代理商默认值， 商户进件默认值
  let ifNotsetContinue = (mergeFeeProps === 'agentdefFee' || mergeFeeProps === 'mchapplydefFee' )

  let result: any = []

  for (let index = 0; index < list.length; index++) {
    let element = list[index]

    let thisWayCode = element.wayCode
    
    // 只包含进件的数据 && 当前数据行不支持进件  // 20230228 不在校验。 
    // if (filterApplymentSupport && !showMchApplyment(thisWayCode)) {
    //  continue
    // }

    // 根据产品ID查询 合并模式的信息 
    let mergeFeeArray : any = getMergeFeeObjectByWaycode(thisWayCode)
    let mergeFee : any = mergeFeeArray[0]
    let mergeFeeChecked : any = mergeFeeArray[1]

    // 正常情况下， 不会存在空的情况。 
    if(mergeFee == null ){
      continue
    }

    // 合并模式 && 合并模式的开关为 关闭状态时 
    if(mergeFee.isMergeMode == 1 && mergeFee.mainFee.state != 1){
      continue
    }

    // 合并模式 && 未勾选此支付产品
    if(mergeFee.isMergeMode == 1 && !mergeFeeChecked){
      continue
    }

    // 合并模式
    if(mergeFee.isMergeMode){

      // console.log('合并模式 isMergeMode= true， 合并的数据： ', mergeFee[mergeFeeProps])

      element = JSON.parse(JSON.stringify(mergeFee[mergeFeeProps]))
      element.wayCode = thisWayCode // 恢复wayCode 
      element.state = 1 // 如果合并模式 & 代理商默认 可能为 0 ， 前面已经判断了， 此处不再判断。 

    }else{  // 拆分模式

      // 拆分模式:  代理商默认、 商户进件默认都获取的是  主配置的状态 ， 此处直接赋值。 
      element.state = vdata.mainRateMap[thisWayCode].state

    }

    // 状态： 未开通。  不再循环。   这里判断的是：  拆分模式的主配置状态。  或者合并模式的状态（前面已经做了判断）
    if(element.state != 1){
      continue
    }

    let obj: any = {}

    obj.wayCode = element.wayCode
    obj.feeType = element.feeType
    obj.state = element.state
    obj.applymentSupport = element.applymentSupport

    // 以下为： state = true的情况

    //单笔费率值
    if (element.feeType == 'SINGLE') {

      // 跳过空值的设置
      if(ifNotsetContinue && (typeof element.feeRate == 'undefined' || element.feeRate === null)){
          continue
      }

      if (typeof element.feeRate != 'number' || element.feeRate < 0) {
        return $infoBox.message.error('费率值不可小于0')
      }
      obj.feeRate = Number.parseFloat((element.feeRate / 100).toFixed(6))

    }else if (element.feeType == 'TRANSMODE') {  //转账模式

      // 跳过空值的设置
      if(ifNotsetContinue && (typeof element.feeRate == 'undefined' || element.feeRate === null)){
          continue
      }

      if (typeof element.feeRate != 'number' || element.feeRate < 0) {
        return $infoBox.message.error('费率值不可小于0')
      }
      obj.feeRate = Number.parseFloat((element.feeRate / 100).toFixed(6))

      if (typeof element.fixFee != 'number' || element.fixFee < 0) {
        return $infoBox.message.error('固定费用不可小于0')
      }
      obj.fixFee = Number.parseInt( (element.fixFee * 100).toFixed(0)  )

      if (typeof element.minFee != 'number' || element.minFee < 0) {
        return $infoBox.message.error('保底费用不可小于0')
      }
      obj.minFee = Number.parseInt( (element.minFee * 100).toFixed(0)  )

      if (typeof element.maxFee != 'number' || element.maxFee < 0) {
        return $infoBox.message.error('封顶费用不可小于0')
      }
      obj.maxFee = Number.parseInt( (element.maxFee * 100).toFixed(0)  )


    } else {
      // 阶梯费率

      let convertResult = levelFeeElementConvertObj(obj, element, ifNotsetContinue)
      if (!(convertResult === true)) {
        
        if(ifNotsetContinue){ // 跳过空值的设置
            continue
        }

        // 出现异常
        return false
      }

      // 包含 信用卡的配置项
      if (element.creditCardPaywayFee) {
        let creditCardPaywayFeeObj = {}
        let convertResult2 = levelFeeElementConvertObj(creditCardPaywayFeeObj, element.creditCardPaywayFee, ifNotsetContinue)
        if (!(convertResult2 === true)) {

          if(ifNotsetContinue){ // 跳过空值的设置
            continue
          }

          // 出现异常
          return false
        }

        obj.creditCardPaywayFee = creditCardPaywayFeeObj
      }
    }

    result.push(obj)
  }

  console.log(result)

  return result
}
  
  
  /** 获取到： 商户的费率值 （一般用作进件时的设置费率值）  */
  /** 还有， 盛付通，申请费率调整时需要  */
  function getReqMchRatePaywayFeeList(){
  
    let reqPaywayFeeList = getReqPaywayFeeList()
  
    if(!reqPaywayFeeList){ // 报错
        return false 
    }
  
    return reqPaywayFeeList['MCHRATE']
  }
  
  
  // 判断是否开通了某个支付产品 
  function hasApplymentWaycode(wayCode){
    return ( vdata.mainRateMap[wayCode] && vdata.mainRateMap[wayCode].state == 1 ) 
  }
  

// 获取： 需要显示的名称 
function getShowName(mapName, suffixStr){

  let result = getShowNameNotHasSuffix(mapName)

  if(!result){ // 没有结果， 直接返回原始数据
    return result
  }

  return result + (suffixStr || '费率')

}


// 获取： 需要显示的名称 
function getShowNameNotHasSuffix(mapName){
  
  // 运营平台： 服务商的配置费率模式
  if(props.configMode == 'mgrIsv'){
      if(mapName == 'mainRateMap') return '服务商底价'
      if(mapName == 'agentdefMap' && $hasAgentEnt() ) return '代理商默认'
      if(mapName == 'mchapplydefMap') return '商户进件默认'
  }

  if(props.configMode == 'mgrAgent'){
      if(mapName == 'mainRateMap') return '当前代理商'
      if(mapName == 'agentdefMap' && $hasAgentEnt() ) return '下级代理商默认'
      if(mapName == 'mchapplydefMap' && $hasAgentEnt() ) return '代理商子商户进件默认'
  }

    if(props.configMode == 'agentSelf'){
      if(mapName == 'mainRateMap') return '我的代理'
      if(mapName == 'agentdefMap' && $hasAgentEnt() ) return '下级代理商默认'
      if(mapName == 'mchapplydefMap') return '商户进件默认'
  }

  if(props.configMode == 'agentSubagent'){
      if(mapName == 'mainRateMap') return '代理'
  }

  if(props.configMode == 'mgrMch' || props.configMode == 'agentMch' ){
      if(mapName == 'mainRateMap') return '商户'
  }

  if(props.configMode == 'mgrApplyment' || props.configMode == 'agentApplyment'){
      if(mapName == 'mainRateMap') return '进件'
  }

  if(props.configMode == 'mchSelfApp1'){
    if(mapName == 'mainRateMap') return '接口'
  }

 
  // 新添加的判断逻辑：  
  if(props.configMode == 'mchApplyment'){
    if(mapName == 'mainRateMap') return '进件'
  }


  return ''
}

// 判断当前页面是否是：  普通商户的配置 
function isNormalMchPage(){

  // 商户配置页面 && 不包含某些字段。 
  return props.configMode == 'mgrMch' && ( !vdata.savedMapDataHasReadonlyIsvCostRateMap ) 
  
}

// 重新加载费率 来自复制的参数项
function reloadRateDataPageByParse(reloadRateData){
  reloadRatePanel(reloadRateData) 
}


// 判断是否为： 转账产品
function checkIsTransferIfProduct(ifCodeItem){

  if(!ifCodeItem){
    return false
  }

  // 当前是转账获取 类型的转账
  if(ifCodeItem.wayCode == 'TRANSFER' || ifCodeItem.wayType == 'TRANSFER'){
    return true
  }

  return false

}


  // 向子组件注入： vdata全部数据  parent data 
provide('pvdata', computed( ()=> vdata) )

// getShowName 在一个地方维护
provide('getShowNameFunc', getShowName )
  

provide('isNormalMchPageFunc', isNormalMchPage )

defineExpose({getReqMchRatePaywayFeeList, hasApplymentWaycode, reloadRateDataPageByParse})
  
  
  </script>
  
  <style lang="less" scoped>
  .drawer {
    /* position: relative; */
    border-radius: 10px;
    background: #fff;
    border-radius: 10px;
    padding: 30px;
    padding-bottom: 0;
  }


  .drawer-btn-center-payfee {
    // display: flex;
    // justify-content: space-between;
    position: absolute;
    right: 0px;
    width: 100%;
    border-top: 1px solid rgb(233, 233, 233);
    padding: 10px 16px;
    background: rgb(255, 255, 255);
    text-align: center;
    z-index: 160;

    &:first-child {
      margin-right: 80px;
    }
    button {
      margin: 0;
      padding: 3px 20px;
    }
  }

  </style>
  